home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 06 - 1990 / 06.07 Jul 90 / Printing Primer ƒ / ReportUtils.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-11-21  |  18.1 KB  |  928 lines  |  [TEXT/KAHL]
  1. /*******************************************\
  2. *    file:         ReportUtils.c                *
  3. *    version:    1.0ß                        *
  4. *                                            *
  5. *    Common routines for printing reports    *
  6. *                                            *
  7. * -----------------------------------------    *
  8. * By:    Donald Koscheka                        *
  9. * Date:    30-OCT-89                            *
  10. * ©    Copyright 1989, Donald Koscheka            *
  11. *    All Rights Reserved                        *
  12. *                                            *
  13. * -----------------------------------------    *
  14. \*******************************************/
  15.  
  16. #include <MacTypes.h>
  17. #include <MemoryMgr.h>
  18. #include <ResourceMgr.h>
  19. #include <OSUtil.h>
  20. #include <HyperXCmd.h>
  21. #include <HyperUtils.h>
  22. #include <PrintMgr.h>
  23. #include <ReportUtils.h>
  24.  
  25.                 /****************************************************/
  26.                 /*             --- MISCELLANEOUS UTILITIES ---            */
  27.                 /*                                                    */
  28.                 /****************************************************/
  29.                 
  30. short    getStringHandleSize( h )
  31.         Handle    h;
  32. /******************************
  33. * In hypercard, strings are padded
  34. * out to even boundaries so that the
  35. * handle size may be longer than
  36. * you'd like.
  37. * 
  38. * This routine returns the length
  39. * of the string up to but not 
  40. * including the NULL
  41. *
  42. * This routine is to be used for 
  43. * NULL terminated strings only!
  44. *
  45. *******************************/
  46. {
  47.     short    i    = 0;
  48.     char    *endPoint;
  49.     
  50.     if( validHandle( h ) ){
  51.         i = (short)GetHandleSize( h );
  52.     
  53.         endPoint = *h + i - 1;
  54.         while( *endPoint ){
  55.             --i;
  56.             --endPoint;
  57.         }
  58.     }
  59.     return( i );
  60. }
  61.  
  62.  
  63.  
  64. short    strNComp( s1, s2, len )
  65.     char    *s1;
  66.     char    *s2;
  67.     long    len;
  68. /******************************
  69. *
  70. ******************************/
  71. {
  72.     short    indx;
  73.     short    match = 1;
  74.     
  75.     for( indx = 1; indx <= len; indx++ )
  76.         if( *s1++ != *s2++ ){
  77.             match = 0;
  78.             break;
  79.         }
  80.     return( match );
  81. }
  82.  
  83.                 /****************************************************/
  84.                 /*             --- PARSING ROUTINES ---                */
  85.                 /*                                                    */
  86.                 /****************************************************/
  87.  
  88.  
  89. long matchToken( buf, tabl )
  90.     Handle    buf;
  91.     short    tabl;
  92. /******************************
  93. * given an input buffer and the resource 
  94. * id of the parse table, return 
  95. * the token that represents the input
  96. * string.
  97. *
  98. * A token of 0 is returned if no
  99. * match is found.  This way, you
  100. * can use the first item in the list
  101. * as the default item!
  102. *
  103. * The symbol table should have the 
  104. * format:
  105. *
  106. *    <string>, <token>
  107. * 
  108. * where string mathces to the input
  109. * string and token is that value for 
  110. * a given match.
  111. ******************************/
  112. {
  113.     char    *bp;            /*** pointer to input strings            ***/
  114.     char    *tp;
  115.     Handle    strH;            /*** handle to parse strings resource    ***/
  116.     long    token     = 0;    /*** return the default if no match        ***/
  117.     short    indx    = 0;
  118.     short    theID;
  119.     ResType    theType;    
  120.     short    done = 0;
  121.     long    len;
  122.     char    theNum[31];    
  123.     char    *np;
  124.     char    theName[256];
  125.     char    theString[256];
  126.         
  127.     bp = *buf;
  128.     
  129.     tp = bp;
  130.     while( *tp ){
  131.         toupper( *tp );
  132.         tp++;
  133.     }
  134.     
  135.     strH     = GetResource( STRING_TYPE, tabl );
  136.     
  137.     if( strH ){
  138.         
  139.         GetResInfo( strH, &theID, &theType, &theName );
  140.         
  141.         /*** compare the string to the allowable tokens ***/
  142.         indx    = 1 ;
  143.         
  144.         while( !done ){
  145.             theString[0] = '\0';
  146.             GetIndString( &theString, tabl, indx );
  147.             
  148.             if( theString[0] == '\0' )    /* no strings matched the input     */
  149.                 done = 1;
  150.             else{                        /* attempt to match to current str    */
  151.                 
  152.                 PtoCstr( (char *)&theString );
  153.                 
  154.                 len = 0;
  155.                 
  156.                 bp = theString;
  157.                 while ( *bp != ',' ){
  158.                     bp++;
  159.                     len++;
  160.                 }
  161.             
  162.                 if( strncmp( *buf, (char *)theString, len ) == 0){
  163.                     /* have a match so extract the token    */                    
  164.                     
  165.                     /*** move past any garbage in the string ***/
  166.                     while( (*bp < '0' || *bp > '9') && *bp != '-')
  167.                         bp++;
  168.                     
  169.                     /*** now copy what bp points to into a     ***/
  170.                     /*** a pascal style string                ***/
  171.                     
  172.                     theNum[0] = '\0';
  173.                     np = &theNum[1];
  174.                     
  175.                     while( *bp >= '0' && *bp <= '9' ){
  176.                         theNum[0]++;
  177.                         *np++ = *bp++;
  178.                     }
  179.                     
  180.                     /*** np is a valid p-string                ***/
  181.                     StringToNum( theNum, &token );
  182.                     done = 1;
  183.                 }
  184.                 else
  185.                     indx++;
  186.             }
  187.         }
  188.     }
  189.     
  190.     return( token );
  191. }
  192.  
  193.  
  194. long    parseNum( bp )
  195.             char    *bp;
  196. /******************************
  197. * parse the data stream 
  198. * and return a numeric 
  199. * value.  The stream is null
  200. * terminated.
  201. *
  202. ******************************/
  203. {
  204.     long    num = 0;
  205.     
  206.     char    theString[256];
  207.     short    done = 0;
  208.     char    *ps;
  209.         
  210.     /*** move the input pointer until we're looking at a number    ***/
  211.     while( *bp && ( *bp < '0' || *bp > '9' ) && *bp != '-' )
  212.         bp++;
  213.     
  214.     /*** copy the data into a pascal string     ***/
  215.     ps    = theString;
  216.     ps++;
  217.     
  218.     while( *bp >= '0' && *bp <= '9' )
  219.         *ps++ = *bp++;
  220.     
  221.     /*** moved one past the output so try this    ***/
  222.     theString[0] = (char)( ps - theString -1  );    
  223.     StringToNum( theString, &num );
  224.     
  225.     return( num );    
  226. }
  227.  
  228.  
  229.  
  230. char    *nextToken( bp )
  231.             char    *bp;
  232. /******************************
  233. * given a pointer to an
  234. * input stream, move to the 
  235. * next token in the stream. 
  236. * 
  237. * Token's are delineated by
  238. * ',' or whitespace
  239. *
  240. * Assumes we are pointing to the current token
  241. * Move past the current token and the white
  242. * space that follows it.
  243. ******************************/
  244. {
  245.     /*** move past the current token    ***/
  246.     while( *bp &&(*bp != ',' && *bp != SPACE && *bp != CR && *bp != LF && *bp != TAB) )
  247.         bp++;
  248.  
  249.     /*** move past the white space to the next token    ***/
  250.     while( *bp == ',' || *bp == SPACE || *bp == CR || *bp == LF || *bp == TAB )
  251.         bp++;
  252.     
  253.     return( bp );
  254. }
  255.  
  256.  
  257.  
  258. void     parseRect( buf, theRect )
  259.             Handle    buf;
  260.             Rect    *theRect;
  261. /******************************
  262. * parse the data stream 
  263. * into a rectangle
  264. ******************************/
  265. {
  266.     char    *bp;
  267.     
  268.     HLock( buf );
  269.     
  270.     bp = *buf;
  271.     theRect->top = parseNum( bp );
  272.     bp    = nextToken( bp );
  273.     
  274.     theRect->left = parseNum( bp );
  275.     bp    = nextToken( bp );
  276.     
  277.     theRect->bottom = parseNum( bp );
  278.     bp    = nextToken( bp );
  279.     
  280.     theRect->right = parseNum( bp );
  281.     bp    = nextToken( bp );
  282.     
  283.     HUnlock( buf );
  284. }
  285.  
  286.  
  287.  
  288. void    CopyRect( r1, r2 )
  289.         Rect    *r1;
  290.         Rect    *r2;
  291. /****************************
  292. * copy rectangle r1 to r2
  293. *
  294. ****************************/
  295. {
  296.     r2->top     = r1->top;
  297.     r2->left     = r1->left;
  298.     r2->bottom     = r1->bottom;
  299.     r2->right    = r1->right;
  300. }
  301.  
  302.  
  303.     
  304.                 /****************************************************/
  305.                 /*                 --- PRINTING UTILITIES ---            */
  306.                 /*                                                    */
  307.                 /****************************************************/
  308.  
  309.  
  310.  
  311.  
  312.  
  313.  
  314.  
  315. void    FootNotePage( pp )
  316.         pInfoPtr    pp;
  317. /******************************
  318. * draw the footnote for this page
  319. ******************************/
  320. {
  321.     Handle        theText;
  322.     footPtr        myFoot;
  323.     short        siz;
  324.     FontInfo    fInfo;
  325.     short        hite;
  326.     GrafPtr        oldPort;
  327.     styleSet    footStyle;
  328.     char        thePage[32];
  329.     char        theNum[32];
  330.     Rect        temp;
  331.         
  332.     if( pp->footNote.hite ){
  333.         CopyRect( &(pp->margin), &temp );
  334.  
  335.         SetMargin( pp, 0, 0, 0 ,0 );
  336.         
  337.         GetPort( &oldPort );
  338.         SetPort( (GrafPtr)(pp->prPort) );
  339.     
  340.         PenNormal();
  341.     
  342.         footStyle.Font = TIMES;
  343.         footStyle.Size = 12;
  344.         footStyle.Style= PLAIN_TEXT;
  345.         footStyle.Just = teJustLeft;
  346.         
  347.         SetFontStyles( pp, (stylePtr)&footStyle );
  348.         
  349.         GetFontInfo( &fInfo );
  350.         hite     = fInfo.ascent + fInfo.descent + fInfo.leading;
  351.     
  352.         /*** draw the company name and the version number ***/
  353.         if( theText = pp->footNote.key1 ){
  354.             MoveTo( pp->margin.left, pp->margin.bottom+(2*hite)-4 );
  355.             siz = getStringHandleSize( theText );
  356.     
  357.             HLock( theText );        
  358.             DrawTextRun( pp, *theText, siz, teJustLeft );    
  359.             HUnlock( theText );
  360.         }
  361.     
  362.         if( theText = pp->footNote.key2 ){
  363.             MoveTo( pp->margin.left, pp->margin.bottom+(2*hite)-4);
  364.             siz = getStringHandleSize( theText );
  365.     
  366.             HLock( theText );        
  367.             DrawTextRun( pp, *theText, siz, teJustRight );    
  368.             HUnlock( theText );
  369.         }
  370.         
  371.         /*** draw the date and the page number                ***/
  372.         if( theText = pp->footNote.key3 ){
  373.             MoveTo( pp->margin.left, pp->margin.bottom+(3*hite)-4);
  374.             siz = getStringHandleSize( theText );
  375.     
  376.             HLock( theText );        
  377.             DrawTextRun( pp, *theText, siz, teJustLeft );    
  378.             HUnlock( theText );
  379.         }
  380.     
  381.         if( pp->pagecount ){
  382.             thePage[0] = '\0';
  383.             MoveTo( pp->margin.left, pp->margin.bottom+(3*hite)-4);
  384.             strcat( thePage, "Page #");
  385.             NumToString( (long)pp->pagecount, theNum );
  386.             
  387.             PtoCstr( (char *)&theNum );
  388.             strcat( thePage, theNum );
  389.             DrawTextRun( pp, thePage, strlen( thePage ), teJustRight );
  390.         }
  391.  
  392.         CopyRect( &temp, &(pp->margin) );
  393.         SetFontStyles( pp, (stylePtr)&(pp->defaultStyle) );
  394.         SetPort( oldPort );
  395.     }
  396. }
  397.  
  398.  
  399.  
  400. void    EjectPage( pp )
  401.         pInfoPtr    pp;
  402. /******************************
  403. * Eject the current page and 
  404. * adjust the rectangle 
  405. * accordingly
  406. *
  407. ******************************/
  408. {
  409.  
  410.     FootNotePage( pp );
  411.     
  412.     PrClosePage( pp->prPort );
  413.     
  414.     pp->pagecount++;
  415.     pp->totalpages++;
  416.     
  417.     if( pp->totalpages == 128 ){
  418.         TPPrPort    tp;
  419.         PrCloseDoc( pp->prPort );
  420.         
  421.         tp = PrOpenDoc( pp->prRecHandle, NIL, NIL );
  422.         pp->prPort = (GrafPtr)tp;
  423.         pp->totalpages = 0;
  424.         SetPort( (GrafPtr)tp );
  425.     }
  426.     
  427.     PrOpenPage( pp->prPort, NIL );
  428.  
  429.     pp->curntPen.h = pp->margin.left;
  430.     pp->curntPen.v = pp->margin.top;
  431. }
  432.  
  433.  
  434. void     NewLine( pp, y )
  435.         pInfoPtr    pp;
  436.         short        y;
  437. /******************************
  438. * Move to a new position on the
  439. * page checking for page break.
  440. ******************************/
  441. {
  442.     CheckPageBreak( pp, y );
  443.     pp->curntPen.h = pp->margin.left;
  444.     pp->curntPen.v += y;
  445.     MoveTo( pp->curntPen.h, pp->curntPen.v );
  446. }
  447.  
  448.  
  449. void    CheckPageBreak( pp, y )
  450.         pInfoPtr    pp;
  451.         short        y;
  452. /******************************
  453. * Check to see if the current line
  454. * will fit on the page, break the 
  455. * page if not.
  456. *
  457. * This routine manages the pen 
  458. * updating.
  459. *
  460. * √ 10.31.89
  461. ******************************/
  462. {
  463.     if( (pp->curntPen.v + y) >= pp->margin.bottom ){
  464.         EjectPage( pp );
  465.         NewLine( pp, y );
  466.     }    
  467.         
  468.     /* pp->curntPen.v += y; */
  469. }
  470.  
  471.  
  472.  
  473.  
  474.  
  475.     
  476.                 /****************************************************/
  477.                 /*                 --- PORT UTILITIES ---                */
  478.                 /*                                                    */
  479.                 /****************************************************/
  480.  
  481.  
  482.  
  483. void SetMargin( pp, t, l, b, r )
  484.         pInfoPtr    pp;
  485.         short        t;
  486.         short        l;
  487.         short        b;
  488.         short        r;
  489. /******************************
  490. * Reset the margin rectangle in
  491. * the printing rect.
  492. *
  493. * We add to top left and subtract
  494. * from bottom right.
  495. *
  496. * if no parameters specified, then
  497. * set the margin to the page margin.
  498. *
  499. * 11.7.89 adjust bottom margin for
  500. *             footer hite 
  501. ******************************/
  502. {
  503.     register    TPPrint        tp = *(pp->prRecHandle);
  504.     
  505.     pp->margin.top         = tp->prInfo.rPage.top + t;
  506.     pp->margin.left        = tp->prInfo.rPage.left + l;
  507.     pp->margin.bottom    = tp->prInfo.rPage.bottom - b - pp->footNote.hite;
  508.     pp->margin.right    = tp->prInfo.rPage.right - r;
  509. }
  510.  
  511.  
  512.  
  513. void     SetFont( sp, theFont )
  514.         stylePtr    sp;
  515.         short        theFont;
  516. /*******************************
  517. * Reset the font for this document
  518. *******************************/
  519. {
  520.     if( theFont )
  521.         sp->Font = theFont;
  522.     else
  523.         sp->Font = DEFAULT_FONT;
  524. }
  525.  
  526.  
  527.  
  528. void     SetFontSize( sp, theSize )
  529.         stylePtr    sp;
  530.         short        theSize;
  531. /*******************************
  532. * Set the font size for this document
  533. *******************************/
  534. {
  535.     if( theSize )
  536.         sp->Size = theSize;
  537.     else
  538.         sp->Font = DEFAULT_SIZE;
  539. }
  540.  
  541.  
  542.  
  543. void     SetFontStyle( sp, theStyle )
  544.         stylePtr    sp;
  545.         short        theStyle;
  546. /*******************************
  547. * Style is cumulative.  To reset it
  548. * you must set it to plain text.
  549. *******************************/
  550. {
  551.     if( theStyle )
  552.         sp->Style &= theStyle;
  553.     else
  554.         sp->Style = PLAIN_TEXT;
  555. }
  556.  
  557.  
  558.  
  559. void     SetFontJust( sp, theJust )
  560.         stylePtr    sp;
  561.         short        theJust;
  562. /*******************************
  563. *
  564. *******************************/
  565. {
  566.  
  567.     if( theJust )
  568.         sp->Just = theJust;
  569.     else
  570.         sp->Just = teJustLeft;
  571. }
  572.  
  573.  
  574.  
  575. void     SetFontStyles(  pp, sp )
  576.         pInfoPtr    pp;
  577.         stylePtr    sp;
  578. /*******************************
  579. * facilitation piece.  requires some
  580. * thinking yet (not fully happy with
  581. * the data abstractions I've developed
  582. * to this point-- 11.1.89)
  583. *******************************/
  584. {
  585.     GrafPtr        oldPort;
  586.     
  587.     GetPort( &oldPort );
  588.     SetPort( (GrafPtr)(pp->prPort) );
  589.     
  590.     TextFont( sp->Font );
  591.     TextSize( sp->Size );    
  592.     TextFace( sp->Style );
  593.     
  594.     SetPort( oldPort );
  595. }
  596.  
  597.  
  598.  
  599. void    DrawTextRun( pp, tx, len, just )
  600.         pInfoPtr    pp;
  601.         char        *tx;
  602.         short        len;
  603.         short        just;
  604. /**********************************
  605. * Draw the given run of text taking
  606. * without breaking the page.
  607. **********************************/
  608. {
  609.     short    pagewidth    = pp->margin.right - pp->margin.left;
  610.     short    twidth;
  611.     
  612.     /*** need to know the pixel width of the line ***/
  613.     twidth = TextWidth( tx, 0, len );
  614.     
  615.     switch( just ){
  616.         case teJustLeft:
  617.                 break;
  618.                 
  619.         case teJustRight:
  620.                 Move( (pagewidth - twidth), 0 );
  621.                 break;
  622.                 
  623.         case teJustCenter:
  624.                 Move( (pagewidth - twidth)/2, 0 );
  625.                 break;
  626.                 
  627.         case teJustFill:
  628.                 /*** doesn't do anything yet ***/
  629.                 break;
  630.     }/* switch */
  631.     
  632.     DrawText( tx, 0, len );    
  633. }
  634.  
  635.  
  636.  
  637. void     PrintString( pp, theText, hite )
  638.         pInfoPtr    pp;
  639.         Handle        theText;
  640.         short        hite;
  641. /*******************************
  642. * draw the text object passed in
  643. * as a parameter.
  644. *
  645. * titles are always followed by
  646. * blank lines so double the hite 
  647. *******************************/
  648. {
  649.     short        siz;
  650.     FontInfo    fInfo;
  651.  
  652.     NewLine( pp, hite );
  653.     siz = getStringHandleSize( theText );
  654.     DrawTextRun( pp, *theText, siz, teJustLeft );    
  655.     NewLine( pp, hite );
  656.     SetFontStyles( pp, (stylePtr)&(pp->defaultStyle) );
  657. }
  658.  
  659.  
  660.  
  661.  
  662. void    DrawTextLine( pp, tx, len, hite, just )
  663.         pInfoPtr    pp;
  664.         char        *tx;
  665.         short        len;
  666.         short        hite;
  667.         short        just;
  668. /**********************************
  669. * Draw the given run of text taking
  670. * into account page breaks if necessary.
  671. *
  672. * handles justification for the line.
  673. *
  674. * A line is defined as having constant
  675. * vertical position so we only have to move
  676. * the pen horizontally on a line to fit
  677. * it into the correct format.
  678. **********************************/
  679. {
  680.     NewLine( pp, hite );
  681.     DrawTextRun( pp, tx, len, just );
  682. }
  683.  
  684.  
  685.  
  686. void DrawLeftMargin( pp, theLeft, hite )
  687.         pInfoPtr    pp;
  688.         Handle        theLeft;
  689.         short        hite;
  690. /*******************************
  691. * Margins and style are set before
  692. * calling this routine.
  693. *
  694. * EXPERIMENTAL ROUTINE.
  695. *******************************/
  696. {
  697.     Rect        temp;
  698.     
  699.     /*** Draw the labels and answer portions ***/
  700.     if( theLeft && (GetHandleSize( theLeft )) ){
  701.         CopyRect( &(pp->margin), &temp );
  702.         
  703.         pp->margin.right = temp.left - 12;
  704.         MoveTo( pp->margin.left, pp->curntPen.v );
  705.     
  706.         HLock( theLeft );
  707.         DrawTextRun( pp, *theLeft, getStringHandleSize(theLeft ), teJustRight );
  708.         HUnlock( theLeft );
  709.         
  710.         CopyRect( &temp, &(pp->margin) );
  711.         
  712.         SetHandleSize( theLeft, 0L );
  713.     }
  714. }
  715.  
  716.  
  717.  
  718. void DrawRightMargin( pp, theRight, hite )
  719.         pInfoPtr    pp;
  720.         Handle        theRight;
  721.         short        hite;
  722. /*******************************
  723. * the answer gets printed "in the 
  724. * margin"
  725. *
  726. * EXPERIMENTAL ROUTINE.
  727. *******************************/
  728. {
  729.     Rect        temp;
  730.     register    TPPrint        tp = *(pp->prRecHandle);
  731.     
  732.     /*** Draw the labels and answer portions ***/
  733.     if( theRight && (GetHandleSize( theRight )) ){
  734.         CopyRect( &(pp->margin), &temp );
  735.         
  736.         pp->margin.left = pp->margin.right + 30;
  737.         pp->margin.right= tp->prInfo.rPage.right;
  738.         MoveTo( pp->margin.left, pp->curntPen.v  );
  739.         
  740.         HLock( theRight);
  741.         DrawTextRun( pp, *theRight, getStringHandleSize(theRight), teJustLeft  );
  742.         HUnlock( theRight);
  743.         MoveTo( pp->curntPen.h, pp->curntPen.v );
  744.         
  745.         CopyRect( &temp, &(pp->margin) );
  746.         
  747.         SetHandleSize( theRight, 0L );
  748.     }
  749. }
  750.  
  751.  
  752.  
  753. char    *EndOfWord( wPtr, hardline )
  754.         char    *wPtr;
  755.         short    *hardline;
  756. /******************************
  757. * Given a pointer to a  word, calculate the 
  758. * length of the next word in the run. The length
  759. * is determined by adding the width  of each
  760. * character together until a word break.
  761. *
  762. * The difference between tpos and wpos is always
  763. * one word (including the sticky characters)
  764. *
  765. * IN: Pointer to text 
  766. *    wPtr == pointer to NEXT word in
  767. *    run (or NIL if No next word)
  768. *
  769. * adjusts the output ptr which will
  770. * be pointing to the word break character.
  771. *
  772. * first occurrance of space is considered
  773. * part of the word.
  774. ******************************/
  775. {    
  776.     *hardline = 0;
  777.     
  778.     while( 1 ){
  779.         switch( (short)*wPtr ){
  780.             case NULL:
  781.                     return( wPtr );
  782.                     break;
  783.                     
  784.             case QUOTE:
  785.             case COMMA:
  786.             case PERIOD:            
  787.             case TAB:
  788.             case SPACE:
  789.             case ';':
  790.             case '!':
  791.             case '?':
  792.                     ++wPtr;        
  793.                     return( wPtr );
  794.                     break;
  795.                     
  796.             case CR:
  797.             case FF:
  798.                     ++wPtr;
  799.                     *hardline = 1;
  800.                     return( wPtr );
  801.                         break;    
  802.                         
  803.             default:
  804.                     ++wPtr;
  805.                     break;
  806.         }/*** switch( *wPtr ) ****/
  807.     }/*** while(1) ****/
  808. }
  809.  
  810.  
  811.  
  812. void    FlushLine( pp, lineStart, len, just, theLeft, theRight, hite )
  813.         pInfoPtr    pp;
  814.         char        *lineStart;
  815.         short        len;
  816.         short        just;
  817.         Handle        theLeft;
  818.         Handle        theRight;
  819.         short        hite;
  820. /*******************************
  821. * Flush the current line out to 
  822. * the printer.
  823. *
  824. *******************************/
  825. {
  826.     if( len ){
  827.         CheckPageBreak( pp, hite );
  828.         NewLine( pp, hite );
  829.         DrawLeftMargin( pp, theLeft, hite );
  830.         DrawRightMargin( pp, theRight, hite );
  831.         DrawTextRun( pp, lineStart, len, just );
  832.     }
  833. }
  834.  
  835.  
  836.  
  837.  
  838. void     DrawParagraph( pp, theText, theLeft, theRight )
  839.         pInfoPtr    pp;
  840.         Handle        theText;
  841.         Handle        theLeft;
  842.         Handle        theRight;
  843. /*******************************
  844. * Draw the text.  In effect, theLeft
  845. * is the text to the left of the 
  846. * paragraph and theRight is text
  847. * to the right of the paragraph.
  848. *
  849. * Margins and style are set before
  850. * calling this routine.
  851. *
  852. * EXPERIMENTAL ROUTINE.
  853. *******************************/
  854. {
  855.     short        siz;
  856.     FontInfo    fInfo;
  857.     short        hite;
  858.     GrafPtr        oldPort;
  859.     char        *lineStart;
  860.     char        *lineEnd;
  861.     char        *nextWord;
  862.     short        lineWidth    = 0;
  863.     short        wordWidth    = 0;
  864.     short        theMargin;
  865.     short        just;
  866.     short        hardline;
  867.     short        wid;
  868.     
  869.     GetPort( &oldPort );
  870.     SetPort( (GrafPtr)(pp->prPort) );
  871.  
  872.     GetFontInfo( &fInfo );
  873.     hite    = fInfo.ascent + fInfo.descent + fInfo.leading;
  874.     
  875.     NewLine( pp, hite );
  876.     siz = getStringHandleSize( theText );
  877.  
  878.     just        = pp->curntStyle.Just;
  879.     theMargin    = pp->margin.right - pp->margin.left;
  880.     
  881.     HLock( theText );
  882.     
  883.     nextWord = lineStart = lineEnd = *theText;
  884.     
  885.     while( *nextWord ){
  886.     
  887.         /*** loop invariant: lineEnd >= lineStart */
  888.         nextWord = EndOfWord( lineEnd, &hardline );
  889.         wordWidth = TextWidth( lineEnd, 0, (short)((long)nextWord-(long)lineEnd) );
  890.  
  891.         if( wordWidth + lineWidth <= theMargin )
  892.             lineWidth    += wordWidth;
  893.         else{
  894.             wid = (short)((long)lineEnd - (long)lineStart);
  895.             FlushLine(pp, lineStart,wid,just,theLeft,theRight,hite);
  896.             lineWidth = wordWidth;
  897.             lineStart = lineEnd;
  898.         }
  899.         
  900.         if( hardline ){
  901.             lineEnd = nextWord;
  902.             wid = (short)((long)lineEnd - (long)lineStart);
  903.             FlushLine( pp, lineStart, wid, just, theLeft, theRight, hite);
  904.             lineWidth = 0;
  905.             lineStart = lineEnd;
  906.             /*CheckPageBreak( pp, hite );
  907.             NewLine( pp, hite );
  908.             */
  909.         }
  910.         
  911.         lineEnd = nextWord;
  912.         
  913.     }/* while( *nextword ) */
  914.  
  915.     /*** whatever is left in the buffer will fit on one line    ***/
  916.     FlushLine( pp,lineStart,(short)(lineEnd-lineStart),just,theLeft,theRight,hite);
  917.     
  918.     HUnlock( theText );    
  919.     SetPort( oldPort );
  920. }
  921.  
  922.  
  923.  
  924.  
  925.  
  926.  
  927.  
  928.